package gcode

// 模型模板
const modelTemplate = `package model

// {{.ModelName}} 模型
{{if .Comment}}// @Description {{.Comment}}{{end}}
type {{.ModelName}} struct {
	{{- range .Fields}}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`{{.Tag}}`" + `
	{{- end}}
}

{{if .TableName}}
// TableName 表名
func ({{.ModelName}}) TableName() string {
	return "{{.TableName}}"
}
{{end}}
`

// 仓库层模板
const repositoryTemplate = `package repo

import (
	"{{.PackageName}}/internal/model"
	"{{.PackageName}}/internal/dto/request"
	"{{.PackageName}}/internal/dto/response"
	"errors"
	"gorm.io/gorm"
)

// {{.ModelName}}Repo {{.ModelName}}仓库接口
type {{.ModelName}}Repo interface {
	Create(data *model.{{.ModelName}}) error
	Update(data *model.{{.ModelName}}) error
	Delete(id interface{}) error
	FindById(id interface{}) (*model.{{.ModelName}}, error)
	FindList(query *request.{{.ModelName}}Query) (*response.{{.ModelName}}Result, error)
}

// {{.ModelName}}RepoImpl {{.ModelName}}仓库实现
type {{.ModelName}}RepoImpl struct {
	db *gorm.DB
}

// New{{.ModelName}}Repo 创建{{.ModelName}}仓库
func New{{.ModelName}}Repo(db *gorm.DB) {{.ModelName}}Repo {
	return &{{.ModelName}}RepoImpl{
		db: db,
	}
}

// Create 创建记录
func (r *{{.ModelName}}RepoImpl) Create(data *model.{{.ModelName}}) error {
	return r.db.Create(data).Error
}

// Update 更新记录
func (r *{{.ModelName}}RepoImpl) Update(data *model.{{.ModelName}}) error {
	return r.db.Save(data).Error
}

// Delete 删除记录
func (r *{{.ModelName}}RepoImpl) Delete(id interface{}) error {
	return r.db.Delete(&model.{{.ModelName}}{}, id).Error
}

// FindById 根据ID查询
func (r *{{.ModelName}}RepoImpl) FindById(id interface{}) (*model.{{.ModelName}}, error) {
	var data model.{{.ModelName}}
	err := r.db.First(&data, id).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &data, nil
}

// FindList 查询列表
func (r *{{.ModelName}}RepoImpl) FindList(query *request.{{.ModelName}}Query) (*response.{{.ModelName}}Result, error) {
	db := r.db.Model(&model.{{.ModelName}}{})

	// 构建查询条件
	if query != nil {
		// 此处可以根据实际需求添加查询条件
		// 例如：
		// if query.Name != "" {
		//     db = db.Where("name LIKE ?", "%"+query.Name+"%")
		// }
	}

	// 查询总数
	var total int64
	if err := db.Count(&total).Error; err != nil {
		return nil, err
	}

	// 查询数据
	var list []*model.{{.ModelName}}
	
	// 分页查询
	if query != nil && query.PageNum > 0 && query.PageSize > 0 {
		db = db.Offset((query.PageNum - 1) * query.PageSize).Limit(query.PageSize)
	}
	
	if err := db.Find(&list).Error; err != nil {
		return nil, err
	}

	return &response.{{.ModelName}}PageResult{
		Total: total,
		Data:  list,
	}, nil
}
`

// 服务层模板
const serviceTemplate = `package service

import (
	"{{.PackageName}}/internal/model"
	"{{.PackageName}}/internal/repo"
	"{{.PackageName}}/internal/dto/request"
	"{{.PackageName}}/internal/dto/response"
)

// {{.ModelName}}Service {{.ModelName}}服务接口
type {{.ModelName}}Service interface {
	Create(data *model.{{.ModelName}}) error
	Update(data *model.{{.ModelName}}) error
	Delete(id interface{}) error
	FindById(id interface{}) (*model.{{.ModelName}}, error)
	FindList(query *request.{{.ModelName}}Query) (*response.{{.ModelName}}Result, error)
}

// {{.ModelName}}ServiceImpl {{.ModelName}}服务实现
type {{.ModelName}}ServiceImpl struct {
	db *gorm.DB
	repo repo.{{.ModelName}}Repo
}

// New{{.ModelName}}Service 创建{{.ModelName}}服务
func New{{.ModelName}}Service(db *gorm.DB) {{.ModelName}}Service {
	return &{{.ModelName}}ServiceImpl{
		db:   db,
		repo: repo.New{{.ModelName}}Repo(db),
	}
}

// Create 创建记录
func (s *{{.ModelName}}ServiceImpl) Create(data *model.{{.ModelName}}) error {
	return s.repo.Create(data)
}

// Update 更新记录
func (s *{{.ModelName}}ServiceImpl) Update(data *model.{{.ModelName}}) error {
	return s.repo.Update(data)
}

// Delete 删除记录
func (s *{{.ModelName}}ServiceImpl) Delete(id interface{}) error {
	return s.repo.Delete(id)
}

// FindById 根据ID查询
func (s *{{.ModelName}}ServiceImpl) FindById(id interface{}) (*model.{{.ModelName}}, error) {
	return s.repo.FindById(id)
}

// FindList 查询列表
func (s *{{.ModelName}}ServiceImpl) FindList(query *request.{{.ModelName}}Query) (*response.{{.ModelName}}PageResult, error) {
	return s.repo.FindList(query)
}
`

// 控制器模板
const controllerTemplate = `package {{.ModuleName}}

import (
	"strconv"
	"{{.PackageName}}/internal/model"
	"{{.PackageName}}/internal/service"
	"{{.PackageName}}/internal/tool"
	"{{.PackageName}}/internal/dto/request"
	"{{.PackageName}}/internal/dto/response"


	"github.com/gin-gonic/gin"
)

// {{.ModelName}}Controller {{if .Comment}}{{.Comment}}{{else}}{{.ModelName}}控制器{{end}}
type {{.ModelName}}Controller struct {
	service service.{{.ModelName}}Service
}

// New{{.ModelName}}Controller 创建{{.ModelName}}控制器
func New{{.ModelName}}Controller() *{{.ModelName}}Controller {
	return &{{.ModelName}}Controller{
		service: service.New{{.ModelName}}Service(tool.DB),
	}
}

// Create 创建记录
// @Summary 创建{{.ModelName}}
// @Description 创建一条{{.ModelName}}记录
//
// @Tags {{.ModelName}}管理
//
// @Accept json
//
// @Produce json
//
// @Param data body request.{{.ModelName}}CreateRequest true "{{.ModelName}}创建数据"
//
// @Success 200 {object} tool.Response "创建成功"
//
// @Failure 400 {object} tool.Response "参数错误"
//
// @Failure 500 {object} tool.Response "服务器错误"
//
// @Router /{{.LowerModelName}}/create [post]
func (c *{{.ModelName}}Controller) Create(ctx *gin.Context) {
	var req request.{{.ModelName}}CreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.Error(err)
		return
	}

	// 转换为模型
	var data model.{{.ModelName}}
	// 这里可以添加请求DTO到模型的转换代码
	// 简单示例：手动复制字段
	// data.Field1 = req.Field1
	// data.Field2 = req.Field2
	// ...

	if err := c.service.Create(&data); err != nil {
		tool.Err(ctx, "创建失败: " + err.Error())
		return
	}

	tool.Succ(ctx, "创建成功", nil)
}

// Update 更新记录
// @Summary 更新{{.ModelName}}
// @Description 更新一条{{.ModelName}}记录
//
// @Tags {{.ModelName}}管理
//
// @Accept json
//
// @Produce json
//
// @Param data body request.{{.ModelName}}UpdateRequest true "{{.ModelName}}更新数据"
//
// @Success 200 {object} tool.Response "更新成功"
//
// @Failure 400 {object} tool.Response "参数错误"
//
// @Failure 500 {object} tool.Response "服务器错误"
//
// @Router /{{.LowerModelName}}/update [post]
func (c *{{.ModelName}}Controller) Update(ctx *gin.Context) {
	var req request.{{.ModelName}}UpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.Error(err)
		return
	}

	// 检查记录是否存在
	existingData, err := c.service.FindById(req.{{.PrimaryKey}})
	if err != nil {
		tool.Err(ctx, "获取数据失败: " + err.Error())
		return
	}

	if existingData == nil {
		tool.Err(ctx, "数据不存在")
		return
	}

	// 更新字段
	// 这里可以添加请求DTO到模型的转换代码
	// 简单示例：手动复制字段
	// existingData.Field1 = req.Field1
	// existingData.Field2 = req.Field2
	// ...

	if err := c.service.Update(existingData); err != nil {
		tool.Err(ctx, "更新失败: " + err.Error())
		return
	}

	tool.Succ(ctx, "更新成功", nil)
}

// Delete 删除记录
// @Summary 删除{{.ModelName}}
// @Description 删除一条{{.ModelName}}记录
//
// @Tags {{.ModelName}}管理
//
// @Accept json
//
// @Produce json
//
// @Param id path int true "记录ID"
//
// @Success 200 {object} tool.Response "删除成功"
//
// @Failure 400 {object} tool.Response "参数错误"
//
// @Failure 500 {object} tool.Response "服务器错误"
//
// @Router /{{.LowerModelName}}/delete/{id} [delete]
func (c *{{.ModelName}}Controller) Delete(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		tool.Err(ctx, "ID参数错误")
		return
	}

	if err := c.service.Delete(id); err != nil {
		tool.Err(ctx, "删除失败: " + err.Error())
		return
	}

	tool.Succ(ctx, "删除成功", nil)
}

// GetById 根据ID获取记录
// @Summary 获取{{.ModelName}}详情
// @Description 根据ID获取{{.ModelName}}详细信息
//
// @Tags {{.ModelName}}管理
//
// @Accept json
//
// @Produce json
//
// @Param id path int true "记录ID"
//
// @Success 200 {object} tool.Response{data=response.{{.ModelName}}DetailResponse} "获取成功"
//
// @Failure 400 {object} tool.Response "参数错误"
//
// @Failure 404 {object} tool.Response "数据不存在"
//
// @Failure 500 {object} tool.Response "服务器错误"
//
// @Router /{{.LowerModelName}}/detail/{id} [get]
func (c *{{.ModelName}}Controller) GetById(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		tool.Err(ctx, "ID参数错误")
		return
	}

	data, err := c.service.FindById(id)
	if err != nil {
		tool.Err(ctx, "获取数据失败: " + err.Error())
		return
	}

	if data == nil {
		tool.Err(ctx, "数据不存在")
		return
	}

	// 转换为响应DTO
	var resp response.{{.ModelName}}DetailResponse
	// 这里可以添加模型到响应DTO的转换代码
	// 简单示例：手动复制字段
	// resp.Field1 = data.Field1
	// resp.Field2 = data.Field2
	// ...

	tool.Succ(ctx, "获取成功", resp)
}

// GetList 获取列表
// @Summary 获取{{.ModelName}}列表
// @Description 分页获取{{.ModelName}}列表
//
// @Tags {{.ModelName}}管理
//
// @Accept json
//
// @Produce json
//
// @Param query query request.{{.ModelName}}QueryRequest false "查询参数"
//
// @Success 200 {object} tool.Response{data=response.{{.ModelName}}PageResult} "获取成功"
//
// @Failure 500 {object} tool.Response "服务器错误"
//
// @Router /{{.LowerModelName}}/list [get]
func (c *{{.ModelName}}Controller) GetList(ctx *gin.Context) {
	var queryRequest request.{{.ModelName}}QueryRequest
	if err := ctx.ShouldBindQuery(&queryRequest); err != nil {
		ctx.Error(err)
		return
	}

	// 转换为内部查询条件
	query := &request.{{.ModelName}}Query{
		PageNum:  queryRequest.CurrentPage,
		PageSize: queryRequest.PageSize,
		// 这里可以添加请求DTO到模型查询条件的转换代码
		// 简单示例：手动复制字段
		// Field1: queryRequest.Field1,
		// Field2: queryRequest.Field2,
		// ...
	}

	result, err := c.service.FindList(query)
	if err != nil {
		tool.Err(ctx, "获取列表失败: " + err.Error())
		return
	}

	tool.Succ(ctx, "获取成功", result)
}
`

// 路由模板
const routerTemplate = `package v1

import (
	"{{.PackageName}}/internal/handler/{{.ModuleName}}"
	"github.com/gin-gonic/gin"
)

// New{{.ModuleName | capitalize}}Router 创建{{.ModuleName}}路由
func New{{.ModuleName | capitalize}}Router(r *gin.RouterGroup) {
	// 创建控制器
	{{- range .Models}}
	{{$lowerName := . | lowerCamelCase}}
	{{$lowerName}}Controller := {{$.ModuleName}}.New{{.}}Controller()
	{{- end}}

	// 注册路由组
	{{.ModuleName}}Group := r.Group("/{{.ModuleName}}")
	{
		{{- range .Models}}
		{{$lowerName := . | lowerCamelCase}}
		{{$routePath := . | toLower}}
		
		// {{.}} 相关路由
		{{$lowerName}}Group := {{$.ModuleName}}Group.Group("/{{$routePath}}")
		{
			{{$lowerName}}Group.POST("/create", {{$lowerName}}Controller.Create)
			{{$lowerName}}Group.PUT("/update", {{$lowerName}}Controller.Update)
			{{$lowerName}}Group.DELETE("/delete/:id", {{$lowerName}}Controller.Delete)
			{{$lowerName}}Group.GET("/get/:id", {{$lowerName}}Controller.GetById)
			{{$lowerName}}Group.GET("/list", {{$lowerName}}Controller.GetList)
		}
		{{- end}}
	}
}
`

// 请求DTO模板
const requestDtoTemplate = `package request

import (
	"{{.PackageName}}/internal/dto/common"
	"{{.PackageName}}/internal/model"
)

// {{.ModelName}}CreateRequest 创建{{.ModelName}}的请求参数
// @Description 创建{{.ModelName}}的请求参数{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}CreateRequest struct {
	{{- range .Fields}}
	{{- if and (ne .Name "Id") (ne .Name "ID") (ne .Name "CreateTime") (ne .Name "UpdateTime") (ne .Name "DeleteTime") }}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}}\" form:\"{{.ColumnName}}\"{{if .ValidateTag}} binding:\"{{.ValidateTag}}\"{{end}}`" + `
	{{- end}}
	{{- end}}
}

// {{.ModelName}}UpdateRequest 更新{{.ModelName}}的请求参数
// @Description 更新{{.ModelName}}的请求参数{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}UpdateRequest struct {
	{{- if .PrimaryKey}}
	// {{.PrimaryKey}}是必须的
	{{.PrimaryKey}} {{.PrimaryKeyType}} ` + "`json:\"{{.PrimaryKeyColumn}}\" form:\"{{.PrimaryKeyColumn}}\" binding:\"required\"`" + `
	{{- end}}
	{{- range .Fields}}
	{{- if and (ne .Name "Id") (ne .Name "ID") (ne .Name "CreateTime") (ne .Name "UpdateTime") (ne .Name "DeleteTime") (ne .Name $.PrimaryKey) }}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}}\" form:\"{{.ColumnName}}\"`" + `
	{{- end}}
	{{- end}}
}

// {{.ModelName}}QueryRequest {{.ModelName}}查询参数
// @Description {{.ModelName}}查询参数{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}QueryRequest struct {
	{{- range .Fields}}
	{{- if and (ne .Name "CreateTime") (ne .Name "UpdateTime") (ne .Name "DeleteTime") }}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}}\" form:\"{{.ColumnName}}\"`" + `
	{{- end}}
	{{- end}}
	common.PaginationParams
}

// {{.ModelName}}Query 内部查询参数，用于转换请求参数
// @Description 内部查询参数结构体，用于转换请求参数{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}Query struct {
	{{- range .Fields}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}},omitempty\" form:\"{{.ColumnName}},omitempty\"`" + `
	{{- end}}
	PageNum  int ` + "`json:\"pageNum,omitempty\" form:\"pageNum,omitempty\"`" + `
	PageSize int ` + "`json:\"pageSize,omitempty\" form:\"pageSize,omitempty\"`" + `
}
`

// 响应DTO模板
const responseDtoTemplate = `package response

import (
	"{{.PackageName}}/internal/dto/common"
	"{{.PackageName}}/internal/model"
)

// {{.ModelName}}Response {{.ModelName}}基本信息
// @Description {{.ModelName}}基本信息返回结构{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}Response struct {
	{{- range .Fields}}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}}\"`" + `
	{{- end}}
}

// {{.ModelName}}DetailResponse {{.ModelName}}详细信息
// @Description {{.ModelName}}详细信息返回结构{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}DetailResponse struct {
	{{- range .Fields}}
	{{if .Comment}}// {{.Comment}}{{end}}
	{{.Name}} {{.Type}} ` + "`json:\"{{.ColumnName}}\"`" + `
	{{- end}}
	// 其他详细信息字段可在此添加
}

// {{.ModelName}}PageResult {{.ModelName}}分页结果
// @Description {{.ModelName}}分页查询结果{{if .Comment}} - {{.Comment}}{{end}}
type {{.ModelName}}PageResult struct {
	common.PaginationResult[{{.ModelName}}Response]
}
`
